package handler

import (
	"net/http"
	"strconv"

	"pbj-server/internal/model"
	"pbj-server/internal/service"
	"pbj-server/pkg/logger"

	"github.com/gin-gonic/gin"
)

// UserHandler 用户处理器
type UserHandler struct {
	userService *service.UserService
}

// NewUserHandler 创建用户处理器实例
func NewUserHandler(userService *service.UserService) *UserHandler {
	return &UserHandler{
		userService: userService,
	}
}

// Register 用户注册
// @Summary 用户注册
// @Description 用户注册接口
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param user body model.UserRegisterRequest true "用户注册信息"
// @Success 200 {object} Response{data=string} "注册成功"
// @Failure 400 {object} Response{data=string} "请求参数错误"
// @Failure 500 {object} Response{data=string} "服务器内部错误"
// @Router /users/register [post]
func (h *UserHandler) Register(c *gin.Context) {
	var req model.UserRegisterRequest
	
	// 绑定请求参数
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Warnf("用户注册参数绑定失败: %v", err)
		c.JSON(http.StatusBadRequest, Response{
			Code:    400,
			Message: "请求参数错误",
			Data:    err.Error(),
		})
		return
	}
	
	// 调用服务层注册用户
	if err := h.userService.Register(&req); err != nil {
		logger.Errorf("用户注册失败: %v", err)
		c.JSON(http.StatusBadRequest, Response{
			Code:    400,
			Message: err.Error(),
		})
		return
	}
	
	c.JSON(http.StatusOK, Response{
		Code:    200,
		Message: "注册成功",
		Data:    "用户注册成功",
	})
}

// Login 用户登录
// @Summary 用户登录
// @Description 用户登录接口
// @Tags 用户管理
// @Accept json
// @Produce json
// @Param user body model.UserLoginRequest true "用户登录信息"
// @Success 200 {object} Response{data=model.UserLoginResponse} "登录成功"
// @Failure 400 {object} Response{data=string} "登录失败"
// @Router /users/login [post]
func (h *UserHandler) Login(c *gin.Context) {
	var req model.UserLoginRequest
	
	// 绑定请求参数
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Warnf("用户登录参数绑定失败: %v", err)
		c.JSON(http.StatusBadRequest, Response{
			Code:    400,
			Message: "请求参数错误",
			Data:    err.Error(),
		})
		return
	}
	
	// 调用服务层登录
	response, err := h.userService.Login(&req)
	if err != nil {
		logger.Errorf("用户登录失败: %v", err)
		c.JSON(http.StatusBadRequest, Response{
			Code:    400,
			Message: err.Error(),
		})
		return
	}
	
	c.JSON(http.StatusOK, Response{
		Code:    200,
		Message: "登录成功",
		Data:    response,
	})
}

// GetProfile 获取用户资料
// @Summary 获取用户资料
// @Description 获取当前登录用户的资料
// @Tags 用户管理
// @Accept json
// @Produce json
// @Security BearerAuth
// @Success 200 {object} Response{data=model.UserProfileResponse} "获取成功"
// @Failure 401 {object} Response{data=string} "未授权"
// @Router /users/profile [get]
func (h *UserHandler) GetProfile(c *gin.Context) {
	// 从上下文获取用户ID
	userID, exists := c.Get("user_id")
	if !exists {
		c.JSON(http.StatusUnauthorized, Response{
			Code:    401,
			Message: "未授权",
		})
		return
	}
	
	// 调用服务层获取用户资料
	profile, err := h.userService.GetProfile(userID.(uint))
	if err != nil {
		logger.Errorf("获取用户资料失败: %v", err)
		c.JSON(http.StatusBadRequest, Response{
			Code:    400,
			Message: err.Error(),
		})
		return
	}
	
	c.JSON(http.StatusOK, Response{
		Code:    200,
		Message: "获取成功",
		Data:    profile,
	})
}

// UpdateProfile 更新用户资料
// @Summary 更新用户资料
// @Description 更新当前登录用户的资料
// @Tags 用户管理
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param user body model.UserUpdateRequest true "用户资料更新信息"
// @Success 200 {object} Response{data=string} "更新成功"
// @Failure 400 {object} Response{data=string} "更新失败"
// @Router /users/profile [put]
func (h *UserHandler) UpdateProfile(c *gin.Context) {
	var req model.UserUpdateRequest
	
	// 绑定请求参数
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Warnf("更新用户资料参数绑定失败: %v", err)
		c.JSON(http.StatusBadRequest, Response{
			Code:    400,
			Message: "请求参数错误",
			Data:    err.Error(),
		})
		return
	}
	
	// 从上下文获取用户ID
	userID, exists := c.Get("user_id")
	if !exists {
		c.JSON(http.StatusUnauthorized, Response{
			Code:    401,
			Message: "未授权",
		})
		return
	}
	
	// 调用服务层更新用户资料
	if err := h.userService.UpdateProfile(userID.(uint), &req); err != nil {
		logger.Errorf("更新用户资料失败: %v", err)
		c.JSON(http.StatusBadRequest, Response{
			Code:    400,
			Message: err.Error(),
		})
		return
	}
	
	c.JSON(http.StatusOK, Response{
		Code:    200,
		Message: "更新成功",
		Data:    "用户资料更新成功",
	})
}

// GetAllUsers 获取所有用户（管理员功能）
// @Summary 获取所有用户
// @Description 管理员获取所有用户列表
// @Tags 管理员
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param page query int false "页码" default(1)
// @Param page_size query int false "每页数量" default(10)
// @Success 200 {object} Response{data=model.UserListResponse} "获取成功"
// @Failure 403 {object} Response{data=string} "权限不足"
// @Router /admin/users [get]
func (h *UserHandler) GetAllUsers(c *gin.Context) {
	// 获取分页参数
	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
	pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "10"))
	
	// 参数验证
	if page < 1 {
		page = 1
	}
	if pageSize < 1 || pageSize > 100 {
		pageSize = 10
	}
	
	// 调用服务层获取用户列表
	response, err := h.userService.GetAllUsers(page, pageSize)
	if err != nil {
		logger.Errorf("获取用户列表失败: %v", err)
		c.JSON(http.StatusInternalServerError, Response{
			Code:    500,
			Message: "获取用户列表失败",
		})
		return
	}
	
	c.JSON(http.StatusOK, Response{
		Code:    200,
		Message: "获取成功",
		Data:    response,
	})
}

// GetUserByID 根据ID获取用户（管理员功能）
// @Summary 根据ID获取用户
// @Description 管理员根据用户ID获取用户信息
// @Tags 管理员
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param id path int true "用户ID"
// @Success 200 {object} Response{data=model.UserProfileResponse} "获取成功"
// @Failure 404 {object} Response{data=string} "用户不存在"
// @Router /admin/users/{id} [get]
func (h *UserHandler) GetUserByID(c *gin.Context) {
	// 获取用户ID参数
	userIDStr := c.Param("id")
	userID, err := strconv.ParseUint(userIDStr, 10, 32)
	if err != nil {
		c.JSON(http.StatusBadRequest, Response{
			Code:    400,
			Message: "用户ID格式错误",
		})
		return
	}
	
	// 调用服务层获取用户信息
	profile, err := h.userService.GetUserByID(uint(userID))
	if err != nil {
		logger.Errorf("获取用户信息失败: %v", err)
		c.JSON(http.StatusNotFound, Response{
			Code:    404,
			Message: err.Error(),
		})
		return
	}
	
	c.JSON(http.StatusOK, Response{
		Code:    200,
		Message: "获取成功",
		Data:    profile,
	})
}

// UpdateUser 更新用户（管理员功能）
// @Summary 更新用户
// @Description 管理员更新用户信息
// @Tags 管理员
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param id path int true "用户ID"
// @Param user body map[string]interface{} true "用户更新信息"
// @Success 200 {object} Response{data=string} "更新成功"
// @Failure 400 {object} Response{data=string} "更新失败"
// @Router /admin/users/{id} [put]
func (h *UserHandler) UpdateUser(c *gin.Context) {
	// 获取用户ID参数
	userIDStr := c.Param("id")
	userID, err := strconv.ParseUint(userIDStr, 10, 32)
	if err != nil {
		c.JSON(http.StatusBadRequest, Response{
			Code:    400,
			Message: "用户ID格式错误",
		})
		return
	}
	
	// 绑定请求参数
	var updates map[string]interface{}
	if err := c.ShouldBindJSON(&updates); err != nil {
		logger.Warnf("更新用户参数绑定失败: %v", err)
		c.JSON(http.StatusBadRequest, Response{
			Code:    400,
			Message: "请求参数错误",
			Data:    err.Error(),
		})
		return
	}
	
	// 调用服务层更新用户
	if err := h.userService.UpdateUser(uint(userID), updates); err != nil {
		logger.Errorf("更新用户失败: %v", err)
		c.JSON(http.StatusBadRequest, Response{
			Code:    400,
			Message: err.Error(),
		})
		return
	}
	
	c.JSON(http.StatusOK, Response{
		Code:    200,
		Message: "更新成功",
		Data:    "用户更新成功",
	})
}

// DeleteUser 删除用户（管理员功能）
// @Summary 删除用户
// @Description 管理员删除用户
// @Tags 管理员
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param id path int true "用户ID"
// @Success 200 {object} Response{data=string} "删除成功"
// @Failure 400 {object} Response{data=string} "删除失败"
// @Router /admin/users/{id} [delete]
func (h *UserHandler) DeleteUser(c *gin.Context) {
	// 获取用户ID参数
	userIDStr := c.Param("id")
	userID, err := strconv.ParseUint(userIDStr, 10, 32)
	if err != nil {
		c.JSON(http.StatusBadRequest, Response{
			Code:    400,
			Message: "用户ID格式错误",
		})
		return
	}
	
	// 调用服务层删除用户
	if err := h.userService.DeleteUser(uint(userID)); err != nil {
		logger.Errorf("删除用户失败: %v", err)
		c.JSON(http.StatusBadRequest, Response{
			Code:    400,
			Message: err.Error(),
		})
		return
	}
	
	c.JSON(http.StatusOK, Response{
		Code:    200,
		Message: "删除成功",
		Data:    "用户删除成功",
	})
}

// Response 统一响应结构
type Response struct {
	Code    int         `json:"code"`    // 状态码
	Message string      `json:"message"` // 消息
	Data    interface{} `json:"data"`    // 数据
} 